home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / b / b.lha / B / src / bed / unix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-11-24  |  10.6 KB  |  502 lines
  1. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
  2. static char rcsid[] = "$Header: unix.c,v 2.6 85/08/22 16:09:38 timo Exp $";
  3.  
  4. /*
  5.  * B editor -- UNIX interface, i.e. signal and tty fiddling.
  6.  */
  7.  
  8. /* #define BADTABSTOPS /* Obsolete -- "b" doesn't set the tabs any more */
  9.     /* Defined if (soft) tabs may have been placed at strange positions. */
  10.     /* Actually this has only effect if curses(3) is used.
  11.        However this source file doesn't #include "curses.h" so we can't
  12.        check for that, and will assume curses(3) is always used.
  13.        For very slow baudrates when curses(3) is used, it may prove useful
  14.        to undefine BADTABSTOPS.  The "b" shell script must then be modified
  15.        to keep the tabs at the UNIX 8 space apart default. */
  16.  
  17. #include "b.h" /* Only for definitions like bool, string, Hidden etc. */
  18. #include "unix.h" /* What kind of UNIX is this? */
  19.  
  20. #ifdef SIGNAL
  21. #include <signal.h>
  22. #endif SIGNAL
  23.  
  24. #ifdef SGTTY_H
  25. #include <sgtty.h>
  26. #endif SGTTY_H
  27.  
  28. extern bool slowterminal; /* Set for speeds <= 600 baud */
  29. extern bool hushbaby; /* Set if no bells are to be heard */
  30. extern bool dflag; /* Debugging mode */
  31.  
  32.  
  33. #define COPYSAVEFILE ".Bed_buf"
  34.  
  35. Visible char copysavefile[200] = COPYSAVEFILE;
  36.  
  37.  
  38. #define Ctl(x) ('x'&037)
  39.  
  40. #ifndef QUITCHAR
  41. #define QUITCHAR Ctl(\\)
  42. #endif QUITCHAR
  43.  
  44. #ifndef INTRCHAR
  45. #define INTRCHAR Ctl(])
  46. #endif INTRCHAR
  47.  
  48. #define REDRAW Ctl(L) /* From "keys.h" */
  49.  
  50.  
  51. #ifdef SIGNAL
  52. /*
  53.  * Call exit code when signal arrives, then resend the signal.
  54.  */
  55.  
  56. catch(sig)
  57.     int sig;
  58. {
  59.     signal(sig, SIG_DFL);
  60. #ifndef NDEBUG
  61.     fprintf(stderr, "*** Caught signal %d \n\r", sig);
  62.     if (sig == SIGQUIT) { /* QUIT only resets terminal modes */
  63.         endterm();
  64.         endunix();
  65.     }
  66.     else
  67. #endif NDEBUG
  68.         endall();
  69. #ifdef BTOP
  70.     termchild(); /* Kill possible child, but don't wait for it */
  71. #endif BTOP
  72.     kill(getpid(), sig);
  73. }
  74. #endif SIGNAL
  75.  
  76.  
  77. #ifdef SIGTSTP /* I.e., only on BSD systems with job control. */
  78. /*
  79.  * Reset tty modes etc. when STOP signal arrives (control-Z).
  80.  * This is like interrupt but the program may continue later
  81.  * so we must not do all exit code).
  82.  *
  83.  * In order that the code works for 4.1 and 4.2 BSD Unix (V7 and sys III/V
  84.  * don't have the SIGTSTP signal at all, so there wo don't bother), we use
  85.  * neither the awkward "-ljobs" mechanism nor the nicer but (yet!) even
  86.  * less portable sigmask/sigblock system calls.  Rather, to kill ourselves
  87.  * again after the screen and tty modes have been restored, we use another
  88.  * signal, i.e., SIGSTOP (which is uncatchable).
  89.  *
  90.  * Note! Since curses' initscr() also executes signal(SIGTSTP, tstp),
  91.  * and initscr() is called after initunix(), the name of this routine
  92.  * must be tstp, overriding a routine of the same name in the curses
  93.  * library which does not do what we want.
  94.  */
  95.  
  96. tstp(sig)
  97.     int sig;
  98. {
  99.     int (*prevttousig)() = signal(SIGTTOU, SIG_IGN);
  100.         /* Ignore SIGTTOU so stty calls won't stop us again! */
  101.     char cread = REDRAW;
  102.  
  103. #ifndef NDEBUG
  104.     if (dflag)
  105.         fprintf(stderr, "*** Caught stop signal %d \n\r", sig);
  106. #endif NDEBUG
  107.     signal(sig, SIG_DFL);
  108.     endterm();
  109.     unfixttymodes();
  110.     signal(SIGTTOU, prevttousig);
  111.     kill(getpid(), SIGSTOP); /* Hard stop */
  112.  
  113.     /*
  114.      * A stop signal made us go to sleep in Tumbolia.
  115.      * When we awake, we continue at this point.
  116.      * The world may well have changed a little bit,
  117.      * so do the tty initializations anew.
  118.      */
  119.  
  120.     fixttymodes();
  121.     initterm();
  122.  
  123. #ifdef TIOCSTI
  124.     /* Simulate receipt of REDRAW initially so we come up
  125.        with a nice display. */
  126.     ioctl(0, TIOCSTI, &cread);
  127. #endif TIOCSTI
  128.     signal(SIGTSTP, tstp);
  129. }
  130. #endif SIGTSTP
  131.  
  132.  
  133. /*
  134.  * Prepare for interrupts (UNIX `signals') to be caught so
  135.  * we can reset the tty modes and perform miscellaneous other
  136.  * exit routines.
  137.  * Note -- if a signal arrives before the call to fixttymodes,
  138.  * the unfixttymodes may render the terminal useless.  The fix is
  139.  * easy, but I'm too lazy now (just read the statuses BEFORE,
  140.  * but change them only AFTER signal setting).
  141.  */
  142.  
  143. initunix()
  144. {
  145. #ifdef SIGNAL
  146.     register int i;
  147. #endif SIGNAL
  148.  
  149. #ifndef NDEBUG
  150.     if (dflag)
  151.         fprintf(stderr, "*** initunix();\n\r");
  152. #endif NDEBUG
  153.  
  154. #ifdef SIGNAL
  155.     for (i = 1; i <= NSIG; ++i) {
  156. #ifndef NDEBUG
  157.         if (i == SIGQUIT)
  158.             continue;
  159. #endif NDEBUG
  160. #ifdef SIGCONT
  161.         if (i == SIGCONT)
  162.             continue;
  163. #endif SIGCONT
  164. #ifdef SIGCHLD
  165.         if (i == SIGCHLD)
  166.             continue;
  167. #endif SIGCHLD
  168.         if (signal(i, SIG_IGN) != SIG_IGN) {
  169.             signal(i, catch);
  170. #ifndef NDEBUG
  171.             if (dflag)
  172.                 fprintf(stderr, "Catching signal %d\n", i);
  173. #endif NDEBUG
  174.         }
  175.     }
  176.     /* Stop/continue must be handled differently, see stop() above. */
  177. #ifdef SIGTSTP
  178.     if (signal(SIGTSTP, SIG_IGN) != SIG_IGN)
  179.         signal(SIGTSTP, tstp);
  180. #endif SIGTSTP
  181.  
  182. #endif SIGNAL
  183.  
  184. #ifdef SGTTY_H
  185.     fixttymodes();
  186. #endif SGTTY_H
  187.     setcopybuffer();
  188. }
  189.  
  190.  
  191. /*
  192.  * The last termination routine to be called.
  193.  * It also resets all signals to their default status.
  194.  */
  195.  
  196. endunix()
  197. {
  198. #ifdef SIGNAL
  199.     int i;
  200. #endif SIGNAL
  201.  
  202.     fflush(stdout);
  203. #ifndef NDEBUG
  204.     if (dflag)
  205.         fprintf(stderr, "*** endunix();\n\r");
  206. #endif NDEBUG
  207. #ifdef SGTTY_H
  208.     unfixttymodes();
  209. #endif SGTTY_H
  210.  
  211. #ifdef SIGNAL
  212.     for (i = 1; i <= NSIG; ++i)
  213.         signal(i, SIG_DFL);
  214. #endif SIGNAL
  215. }
  216.  
  217.  
  218. /*
  219.  * Determine the name of the file where the copy buffer is saved.
  220.  */
  221.  
  222. Hidden Procedure
  223. setcopybuffer()
  224. {
  225.     string home = getenv("HOME");
  226.  
  227.     if (home)
  228.         sprintf(copysavefile, "%.150s/%.40s", home, COPYSAVEFILE);
  229.     /* Else, retain default initialization! */
  230. }
  231.  
  232.  
  233. /*
  234.  * Return a string like the one that perror(arg) would print
  235.  * (see UNIX manual page perror(3) for details).
  236.  * Like all C library routines returning strings, the string points
  237.  * to static storage that is overwritten on each call.
  238.  * If arg is fairly long, it may get truncated.
  239.  */
  240.  
  241. string
  242. unixerror(arg)
  243.     string arg;
  244. {
  245.     static char msg[200];
  246. #ifdef PERROR
  247.     extern int sys_nerr, errno;
  248.     extern string sys_errlist[];
  249.  
  250.     if (errno > 0 && errno < sys_nerr)
  251.         sprintf(msg, "%.80s: %.80s", arg, sys_errlist[errno]);
  252.     else
  253.         sprintf(msg, "%.80s: UNIX error %d", arg, errno);
  254. #else !PERROR
  255.     sprintf(msg, "%.68s: I/O error", arg);
  256. #endif !PERROR
  257.     msg[80] = '\0';
  258.     return msg;
  259. }
  260.  
  261.  
  262. #ifdef SGTTY_H
  263. /*
  264.  * Hacks to fix certain peculiarities due to the hostile environment
  265.  * in which the editor lives.
  266.  */
  267.  
  268. Hidden struct sgttyb oldtty;
  269.  
  270. #ifdef TIOCSETC
  271. Hidden struct tchars oldtchars;
  272. #endif
  273.  
  274. #ifdef TIOCSLTC
  275. Hidden struct ltchars oldltchars;
  276. #endif
  277.  
  278. Hidden Procedure
  279. fixttymodes()
  280. {
  281.     gtty(2, &oldtty);
  282.     if (oldtty.sg_ospeed <= B600)
  283.         slowterminal = Yes;
  284. #ifdef BADTABSTOPS
  285.     /*
  286.      * Turn on XTABS mode, to be able to live when terminal tabs are
  287.      * set at 4 rather than 8 columns (the B interpreter used to set
  288.      * this).
  289.      */
  290.     if (!(oldtty.sg_flags & XTABS)) {
  291.         struct sgttyb newtty;
  292.         gtty(2, &newtty);
  293.         newtty.sg_flags |= XTABS;
  294.         ioctl(0, TIOCSETN, &newtty);
  295.     }
  296. #endif BADTABSTOPS
  297.  
  298. #ifdef TIOCSETC /* I.e., not at pre-version 7 UNIX systems */
  299.     /*
  300.      * Set the quit character to ^\ and the interrupt at DEL.
  301.      * The start/stop characters are kept only if they are ^S/^Q.
  302.      */
  303.     {
  304.         struct tchars newtchars;
  305.         ioctl(0, TIOCGETC, &oldtchars);
  306.         ioctl(0, TIOCGETC, &newtchars);
  307.         if ((newtchars.t_intrc & 0377) != 0377
  308.             && newtchars.t_intrc != 0177/*DEL*/)
  309.             newtchars.t_intrc = INTRCHAR;
  310.         if ((newtchars.t_quitc & 0377) != 0377)
  311.             newtchars.t_quitc = QUITCHAR;
  312.         if (newtchars.t_startc != Ctl(Q))
  313.             newtchars.t_startc = -1;
  314.         if (newtchars.t_stopc != Ctl(S))
  315.             newtchars.t_stopc = -1;
  316.         ioctl(0, TIOCSETC, &newtchars);
  317.     }
  318. #endif TIOCSETC
  319.  
  320. #ifdef TIOCSLTC /* I.e., at 4.xBSD systems */
  321.     /*
  322.      * Turn off all local control characters except keep stop (^Z) and delayed
  323.      * stop (^Y) when these are the originals.
  324.      */
  325.     {
  326.         static struct ltchars newltchars = {-1, -1, -1, -1, -1, -1};
  327.  
  328.         ioctl(0, TIOCGLTC, &oldltchars);
  329.         if (oldltchars.t_suspc == Ctl(Z))
  330.             newltchars.t_dsuspc = Ctl(Z);
  331.         ioctl(0, TIOCSLTC, &newltchars);
  332.     }
  333. #endif
  334. }
  335.  
  336.  
  337. /*
  338.  * Undo the effects of fixttymodes(), see comments there.
  339.  */
  340.  
  341. Hidden Procedure
  342. unfixttymodes()
  343. {
  344.     if (!oldtty.sg_ospeed)
  345.         return; /* Not yet initialized! */
  346. #ifdef BADTABSTOPS
  347.     ioctl(0, TIOCSETN, &oldtty);
  348. #endif
  349. #ifdef TIOCSETC
  350.     ioctl(0, TIOCSETC, &oldtchars);
  351. #endif
  352. #ifdef TIOCSLTC
  353.     ioctl(0, TIOCSLTC, &oldltchars);
  354. #endif
  355. }
  356. #endif SGTTY_H
  357.  
  358.  
  359. /*
  360.  * Return Yes if more input immediately available
  361.  */
  362.  
  363. #ifdef IBMPC
  364.  
  365. Visible bool
  366. moreinput()
  367. {
  368.     return kbhit();
  369. }
  370.  
  371. #else !IBMPC
  372.  
  373. /*
  374.  * ***** UNIX DEPENDENCE *****
  375.  * Assumes the standard UNIX definition of FILE: assumes there is
  376.  * buffered input if stdin->_cnt > 0, so uses the `_cnt' field.
  377.  *
  378.  * ***** 4.2 BSD DEPENDENCE *****
  379.  * If the symbol SIGNAL is defined, uses the select() system call to determine
  380.  * whether more input is available; see select(2) in 4.2 BSD manual.
  381.  *
  382.  * ***** 4.1 BSD DEPENDENCE *****
  383.  * If the symbol FIONREAD is defined, uses the correponding ioctl call to
  384.  * determine whether more input is available; see tty(4) in 4.1 BSD manual.
  385.  */
  386.  
  387. #ifdef SELECT
  388. #include <sys/time.h>
  389. #endif SELECT
  390.  
  391. Visible bool
  392. moreinput()
  393. {
  394.     if (stdin->_cnt > 0)
  395.         return Yes;
  396. #ifdef SELECT
  397.     {
  398.         int readfds;
  399.         int nfds;
  400.         static struct timeval timeout = {0, 0};
  401.  
  402.         readfds = 1<<fileno(stdin);
  403.         nfds = 1+fileno(stdin);
  404.         nfds = select(nfds, &readfds, (int*)0, (int*)0, &timeout);
  405.         if (nfds > 0) {
  406.             if (dflag)
  407.                 fputc('\07', stderr);
  408.             return Yes;
  409.         }
  410.     }
  411. #else SELECT
  412. #ifdef FIONREAD
  413.     {
  414.         long n = 0;
  415.  
  416.         if (ioctl(0, FIONREAD, &n) != -1 && n > 0)
  417.             return Yes;
  418.     }
  419. #endif FIONREAD
  420. #endif SELECT
  421.     return No;
  422. }
  423. #endif !IBMPC
  424.  
  425.  
  426. #ifdef SETENV
  427. /*
  428.  * Routine to add or change an environment variable.
  429.  * (No longer used.)
  430.  */
  431.  
  432. extern string *environ;
  433.  
  434. setenv(entry)
  435.     string entry;
  436. {
  437.     string equals = index(entry, '=');
  438.     int len;
  439.     string *ep;
  440.     static string *myenviron;
  441.  
  442.     if (!equals)
  443.         syserr("setenv: no = sign");
  444.     len = equals - entry;
  445.     for (ep = environ; *ep && !Strnequ(*ep, entry, len+1); ++ep)
  446.         ;
  447.     if (*ep) {
  448.         *ep = entry;
  449.         return;
  450.     }
  451.     len = ep - environ + 2;
  452.     if (myenviron) {
  453.         myenviron = (string*)
  454.             realloc((string)myenviron, (unsigned)(len * sizeof(string)));
  455.         if (!myenviron)
  456.             syserr("setenv: realloc");
  457.     }
  458.     else {
  459.         myenviron = (string*) malloc((unsigned)(len * sizeof(string)));
  460.         if (!myenviron)
  461.             syserr("setenv: malloc");
  462.         for (ep = environ; *ep; ++ep)
  463.             myenviron[ep-environ] = *ep;
  464.     }
  465.     myenviron[len-1] = (string)NULL;
  466.     myenviron[len-2] = entry;
  467.     environ = myenviron;
  468. }
  469. #endif SETENV
  470.  
  471.  
  472. #ifdef PWB
  473. /*
  474.  * Substitute getenv routine - there is no environment on PWB systems,
  475.  * but as a substitute (not te be encouraged!) we allow a file with the
  476.  * name of the environment variable to contain the desired value;
  477.  * e.g. the file "TERM" may contain a line saying hp2621 or hp etc.
  478.  */
  479.  
  480. Visible string
  481. getenv(name)
  482.     string name;
  483. {
  484.     static char buffer[100];
  485.     FILE *fp;
  486.     string cp;
  487.  
  488.     fp = fopen(name, "r");
  489.     if (!fp)
  490.         return NULL;
  491.     if (!fgets(buffer, sizeof buffer, fp))
  492.         buffer[0] = '\0';
  493.     else {
  494.         cp = index(buffer, '\n');
  495.         if (cp)
  496.             *cp = '\0';
  497.     }
  498.     fclose(fp);
  499.     return buffer;
  500.  }
  501. #endif PWB
  502.